/**
 * 卖酒服务器相关类
 * 
 * + 卖酒服务器类
 * + 关联的商户
 * + 关联的业务员电子名片信息
 */
import { JxbHttpClient } from './session/session';
import store from "../store/index"
import SellingServerAdapter from "../dataAdapter/sellingServerAdapter"
import { CommonBizLogicError } from '../utils/network';

/**
 * 卖酒服务器工具类
 */
export default class SellingServerUtil {

    /**
     * 根据顾问id获取对应的卖酒服务器
     *
     * @param {number|{salesmanVCardId:number}} serverId 业务员id或可以标识顾问的键值对,支持{salesmanVCardId:'名片id'}、{registrySn:'卖酒码序列号'}
     * @returns {Promise<SellingServer>}
     */
    static getInstance(serverId){
        return this._requestServer(serverId)
            .then(data => {
                return new SellingServer(data)
            })
    }

    /**
     * 从服务器端请求信息
     * 
     * @private
     * @param {number|{salesmanVCardId:number}} serverId
     * @returns {Promise<object>}
     */
    static _requestServer(serverId) {
        let data ={}
        if(typeof serverId !== 'object'){
            data = {salesmanId: serverId}
        }else{
            data = serverId
        }
        return (new JxbHttpClient()).request({
            url: 'AppMaster/SellingServer/getServer',
            data: data
        }).then(jxbResps => {
            if(typeof jxbResps.data === "undefined"){
                throw new CommonBizLogicError('未查询到对应的服务器')
            }
            return SellingServerAdapter.convert(jxbResps.data)
        })
    }
    /**
     * @private
     * @param {boolean} allowStranger 包含未曾访问的卖酒服务器，默认 false
     * @returns {Promise<object>}
     */
    static _requestAccessibleServers(allowStranger = false){
        return (new JxbHttpClient()).request({
                url:'AppMaster/SellingServer/accessibleServerCollection',
                data: {
                    allowStranger: allowStranger
                },
                method: 'GET'
            }).then(jxbResps => {
                let serverDataArr = [];
                if(Array.isArray(jxbResps.data.list)){
                    jxbResps.data.list.forEach(rawData => {
                        serverDataArr.push(SellingServerAdapter.convert(rawData))
                    })
                }
                return serverDataArr
            })
    }
    /**
     * 获取可访问的卖酒服务器列表
     * @param {boolean} allowStranger 包含未曾访问的卖酒服务器，默认 false
     * @param {boolean} withCache 使用缓存，默认 true
     * @returns {Promise<SellingServer[]>}
     */
    static getAccessibleServers(allowStranger = false, withCache = true){
        let cacheName = 'AccessibleSellingServers'+(allowStranger?'All':''), 
            servers = store.global(cacheName), prom
        if(withCache && servers && servers.length > 0){
            prom = new Promise(resolve => {
                resolve(servers)
            })
        }else{
            prom = this._requestAccessibleServers(allowStranger).then(serverDataArr => {
                let servers = []
                serverDataArr.forEach(serverData => {
                    servers.push(new SellingServer(serverData))
                })
                store.global(cacheName, servers)
                return servers
            })
        }
        return prom
    }

}

/**
 * 卖酒服务器类
 */
export class SellingServer 
{

    /**
     * @protected
     * @property {object} 源数据
     */
    _data

    /**
     * @returns {string} 卖酒服务器的名字/店铺的名字
     */
    get showName(){
        return this._data.showName + ''
    }
    /**
     * @returns {number} 业务员id
     */
    get salesmanId(){
        return isNaN(this._data.salesmanId)?0:parseInt(this._data.salesmanId)
    }
    /**
     * @returns {boolean} 卖酒服务器是否可以提供服务 true = 可以提供服务；false = 不可以提供服务（不可以找他买酒）
     */
    get isServiceable(){
        return !!this._data.isServiceable
    }
    /**
     * 获取当前访问的卖酒服务器所属商户
     * 
     * @returns {Promise<Agent>} 商户实例
     */
    getTheAgent(){
        return new Promise(resolve=>{
            resolve(new Agent(this._data.agentData))
        })
    }
    /**
     * 获取当前访问的卖酒服务器所属商户（同步）
     * 
     * **Bug&Tips**
     * 
     * + 调用前请确保本地有相关的缓存数据，否则请对返回结果进行判断
     * + 获取失败将返回null
     * @returns {Agent}
     */
    getTheAgentSync(){
        if(typeof this._data.agentData === 'object' && Object.keys(this._data.agentData).length > 0){
            return new Agent(this._data.agentData)
        }
        return null
    }
    /**
     * 获取当前访问的卖酒服务器所属顾问的名片
     * 
     * @returns {SalesmanVCard}  电子名片
     */
    getTheVCard(){
        return new Promise(resolve => {
            resolve(new SalesmanVCard(this._data.vCardData))
        })
    }
     /**
     * 获取当前访问的卖酒服务器所属顾问的名片（同步）
     * 
     * **Bug&Tips**
     * 
     * + 调用前请确保本地有相关的缓存数据，否则请对返回结果进行判断
     * + 获取失败将返回null
     * @returns {SalesmanVCard}
     */
    getTheVCardSync(){
        if(typeof this._data.vCardData === 'object' && Object.keys(this._data.vCardData).length > 0){
            return new SalesmanVCard(this._data.vCardData)
        }
        return null
    }
    /**
     * 获取上一次访问的卖酒服务器
     * 
     * @returns {SellingServer} 上次访问的卖酒服务器信息
     */
    getTheLastAccessedServer(){
        return new Promise(resolve => {
            resolve(new SellingServer(this._data.lastServerData))
        })
    }
     /**
     * 获取上一次访问的卖酒服务器（同步）
     * 
     * **Bug&Tips**
     * 
     * + 调用前请确保本地有相关的缓存数据，否则请对返回结果进行判断
     * + 获取失败将返回null
     * @returns {SellingServer}
     */
    getTheLastAccessedServerSync(){
        if(typeof this._data.lastServerData === 'object' && Object.keys(this._data.lastServerData).length > 0){
            return new SellingServer(this._data.lastServerData)
        }
        return null
    }

    /**
     * @param {object} initData 实例初始化时需要的数据
     */
    constructor(initData = {}) {
        if(typeof initData === 'object' && Object.keys(initData).length > 0){
             this._data = initData
        }
    }
}

/**
 * 商户
 */
class Agent 
{
    /**
     * @protected
     * @property {object} 源数据
     */
    _data
    /**
     * @returns {number} 商户id
     */
    get id(){
        return parseInt(this._data.id)
    }
    /**
     * @returns {string} 商户序列号
     */
    get sn(){
        if(typeof this._data.sn !== 'string' || this._data.sn.length === 0){
            this._data.sn = this.id.toString(36)
        }
        return String.prototype.toUpperCase(this._data.sn)
    }
    /**
     * @returns {string} 商户名
     */
    get name(){
        return this._data.name
    }
    
    /**
     * @returns {string} 展示名称
     */
    get showName(){
        return (typeof this._data.showName === 'string' && this._data.showName.length > 0) ? this._data.showName : this._data.name
    }
    /**
     * @returns {string} 商户logo
     */
    get logoUri(){
        return this._data.logoUri
    }
    /**
     * @returns {boolean} 客户注册入口是否已关闭 true=已关闭， false=开放注册
     */
    get customerRegistrationClosed(){
        return !!this._data.customerRegistrationClosed
    }
    /**
     * @returns {boolean} 商品价格是否隐藏，true = 隐藏， false = 展示
     */
    get goodsPriceHidden(){
        return !!this._data.goodsPriceHidden
    }
    /**
     * @returns {boolean} 销售业务类型， true=批发，false = 零售
     */
    get isWholesale(){
        return !!this._data.isWholesale
    }

    /**
     *获取展示的语言
     *
     * jxb = 酒类行业语言， com = 通用行业语言
     * @readonly
     * @memberof Agent
     */
    get langShown(){
        if(typeof this._data.langShown !== 'string' || this._data.langShown.length === 0){
            return 'jxb'
        }
        return this._data.langShown;
    }
    /**
     * @returns {boolean} 商品列表展示侧边栏 true=展示侧边栏
     * @readonly
     * @memberof Agent
     */
    get isShowItemListMenu(){
        return !!this._data.isShowItemListMenu
    }
    /**
     * @returns {string} 购物车空白占位图
     */
    get emptyShopCartBgUri(){
        return this._data.emptyShopCartBgUri
    }
    /**
     * @param {object} initData 实例初始化时需要的数据
     */
    constructor(initData = {}) {
        if(typeof initData === 'object' && typeof initData.id !== 'undefined'){
             this._data = initData;
        }
    }
}

/**
 * 业务员电子名片
 */
export class SalesmanVCard
{
    /**
     * @protected
     * @property {object} 源数据
     */
    _data
    /**
     * @returns {int} 电子名片id
     */
    get id(){
        return this._data.id
    }
    /**
     * @returns {string} 姓名
     */
    get name(){
        return this._data.name + ''
    }
    /**
     * @returns {string} 头像地址
     */
    get avatarUri(){
        return this._data.avatarUri + ''
    }
    /**
     * @returns {string} 联系电话
     */
    get contactPhone(){
        return this._data.contactPhone + ''
    }
    /**
     * @returns {string} 联系邮箱
     */
    get contactEmail(){
        return this._data.contactEmail + ''
    }
    /**
     * @returns {string} 联系地址
     */
    get address(){
        return this._data.address+''
    }
    /**
     * @returns {string} 简介信息
     */
    get introduction(){
        return this._data.introduction + ''
    }
    /**
     * @returns {string} 店铺名称
     */
    get shopName(){
        return this._data.shopName + ''
    }
    /**
     * @returns {number} 性别标识 1=男 2=女
     */
    get genderId(){
        return (!isNaN(this._data.genderId))? parseInt(this._data.genderId) : 0
    }
    /**
     * @returns {string} 性别（文本描述）
     */
    get gender(){
        return this._data.gender?this._data.gender:'未设置'
    }
    /**
     * @return {number} 年龄
     */
    get age(){
        return (!isNaN(this._data.age)) ? parseInt(this._data.age) : (new Date()).getFullYear() - this.birthYear + 1
    }
    /**
     * @returns {number} 出生年份
     */
    get birthYear(){
        return (!isNaN(this._data.birthYear)) ? parseInt(this._data.birthYear) : (new Date()).getFullYear() - 35
    }
    /**
     * @returns {string} 职业
     */
    get career(){
        return this._data.career
    }
    /**
     * @returns {string} 职位
     */
    get jobTitle(){
        return this._data.jobTitle + ''
    }
    /**
     * @returns {boolean} 顾问名片敏感信息是否对客户保密
     */
    get keepSecret(){
        return !!this._data.keepSecret
    }
    get tags(){
        return this._data.tags?this._data.tags:[]
    }
    /**
     * @param {object} initData 实例初始化时需要的数据
     */
    constructor(initData = {}) {
        if(typeof initData === 'object' && typeof initData.id !== 'undefined'){
             this._data = initData
        }
    }
}